import { buildPrompt, generateResponse, updateConversationState, addMessageToConversation, getOrCreateConversation } from './modelService.js';

// 评估维度定义
const ASSESSMENT_DIMENSIONS = [
  {
    name: '职业认知',
    description: '对目标职业的了解程度，包括工作职责、发展路径、行业趋势等',
    priority: 1 // 优先级，数值越小优先级越高
  },
  {
    name: '专业技能',
    description: '与目标职业相关的专业知识和技能掌握程度',
    priority: 2
  },
  {
    name: '通用能力',
    description: '适用于各种职业的基础能力，如沟通、协作、解决问题等',
    priority: 3
  },
  {
    name: '求职技能',
    description: '求职过程中需要的技能，如简历制作、面试技巧等',
    priority: 4
  },
  {
    name: '心理素质',
    description: '面对就业压力和挑战的心理状态和应对能力',
    priority: 5
  },
  {
    name: '环境适应',
    description: '适应新工作环境和角色转变的能力',
    priority: 6
  }
];

// 每个维度的问题模板库（每个维度至少5个问题）
const QUESTION_TEMPLATES = {
  '职业认知': [
    '你对{{industry}}行业中{{profession}}岗位的主要工作职责了解多少？',
    '你认为{{industry}}行业的{{profession}}在未来3-5年内的发展前景如何？',
    '在{{industry}}行业中，{{profession}}的职业晋升路径通常是怎样的？',
    '你了解{{industry}}行业中{{profession}}岗位的薪资结构和水平吗？',
    '{{industry}}行业的{{profession}}岗位面临的主要挑战有哪些？'
  ],
  '专业技能': [
    '作为{{industry}}行业的{{profession}}，你认为需要掌握哪些核心专业技能？',
    '你在{{profession}}相关技能方面有哪些实际的项目经验？',
    '你如何评价自己在{{profession}}核心技能方面的掌握程度？',
    '你最近学习了哪些与{{industry}}行业{{profession}}相关的新技术或知识？',
    '在实际工作中，你如何将理论知识应用到{{profession}}的具体工作中？'
  ],
  '通用能力': [
    '在团队合作中，你通常扮演什么角色？能否分享一次成功的团队合作经历？',
    '当你遇到工作中的困难或挑战时，你通常是如何解决的？',
    '你认为良好的沟通能力在{{industry}}行业的{{profession}}工作中有多重要？',
    '你如何管理时间和安排工作优先级？',
    '在面对压力时，你有哪些有效的应对策略？'
  ],
  '求职技能': [
    '你是如何为{{industry}}行业的{{profession}}岗位准备简历的？',
    '你对{{industry}}行业的面试流程和常见问题了解多少？',
    '在面试中，你通常如何向面试官展示自己的优势？',
    '你通过哪些渠道了解和获取{{industry}}行业的招聘信息？',
    '你如何评估一个工作机会是否适合自己？'
  ],
  '心理素质': [
    '面对就业压力时，你通常会采取哪些方式来调整自己的心态？',
    '你对自己的职业发展有什么短期和长期的规划？',
    '如果求职过程中遇到挫折，你会如何应对？',
    '你如何看待工作与生活的平衡？',
    '你对自己的优势和不足有清晰的认识吗？能否简单分享一下？'
  ],
  '环境适应': [
    '如果需要适应新的工作环境和团队，你会采取哪些措施？',
    '你如何看待工作中的变化和不确定性？',
    '在学生角色向职场角色转变的过程中，你认为最大的挑战是什么？',
    '你是否有过在不同环境中工作或学习的经历？是如何适应的？',
    '你如何处理工作中的人际关系和沟通问题？'
  ]
};

// 行业和职业正则匹配模式（4种基础模式）
const INDUSTRY_PROFESSION_PATTERNS = [
  // 模式1: 行业-职业 格式
  /(\S+)行业[\s-]+(\S+)/,
  // 模式2: 职业in行业 格式
  /(\S+)\s*in\s*(\S+)/i,
  // 模式3: 职业+行业 格式
  /(\S+)\s+(\S+)行业/,
  // 模式4: 简单的行业 职业 组合
  /(\S+)\s+(\S+)/
];

// 存储已使用的问题，避免重复
const usedQuestions = new Map();

/**
 * 初始化评估
 * @param {string} conversationId 会话ID
 * @returns {object} 初始化结果
 */
function initializeAssessment(conversationId) {
  // 初始化会话状态
  const initialState = {
    currentDimensionIndex: 0,
    questionsAsked: 0,
    questionsPerDimension: 3,
    dimensionQuestionCounts: {},
    dimensionScores: {},
    totalScore: 0,
    isCompleted: false,
    industry: null,
    profession: null,
    initialMessage: '您好！请问您想了解哪个行业的哪个职业呢？例如：互联网行业-数据分析师、制造业-机械工程师、金融业-客户经理等。'
  };
  
  // 初始化每个维度的问题计数
  ASSESSMENT_DIMENSIONS.forEach(dim => {
    initialState.dimensionQuestionCounts[dim.name] = 0;
    initialState.dimensionScores[dim.name] = 0;
  });
  
  // 更新会话状态
  updateConversationState(conversationId, initialState);
  
  // 初始化已使用问题记录
  usedQuestions.set(conversationId, new Set());
  
  return initialState;
}

/**
 * 解析用户输入的行业和职业信息
 * @param {string} conversationId 会话ID
 * @param {string} userInput 用户输入
 * @returns {Promise<object>} 解析结果
 */
async function parseIndustryProfession(conversationId, userInput) {
  try {
    // 使用正则表达式尝试匹配
    for (const pattern of INDUSTRY_PROFESSION_PATTERNS) {
      const match = userInput.match(pattern);
      if (match) {
        let industry, profession;
        
        // 根据模式确定哪个是行业，哪个是职业
        if (match[1].includes('行业')) {
          industry = match[1].replace('行业', '').trim();
          profession = match[2].trim();
        } else if (match[2].includes('行业')) {
          industry = match[2].replace('行业', '').trim();
          profession = match[1].trim();
        } else {
          // 默认第一个为行业，第二个为职业
          industry = match[1].trim();
          profession = match[2].trim();
        }
        
        // 更新会话状态
        updateConversationState(conversationId, {
          industry,
          profession
        });
        
        return { success: true, industry, profession };
      }
    }
    
    // 如果正则匹配失败，使用大模型进行解析
    const prompt = buildPrompt('industry_profession_parse', userInput);
    const response = await generateResponse(prompt);
    
    // 解析响应
    try {
      const parsed = JSON.parse(response);
      
      if (parsed.industry && parsed.profession) {
        // 更新会话状态
        updateConversationState(conversationId, {
          industry: parsed.industry,
          profession: parsed.profession
        });
        
        return { success: true, ...parsed };
      }
    } catch (e) {
      console.error('Failed to parse industry/profession from model response:', e);
    }
    
    // 如果所有解析方法都失败，使用默认值
    const defaultResult = { industry: '互联网', profession: '软件工程师' };
    
    // 更新会话状态
    updateConversationState(conversationId, defaultResult);
    
    return { success: false, ...defaultResult };
  } catch (error) {
    console.error('Error parsing industry/profession:', error);
    
    // 返回默认值
    const defaultResult = { industry: '互联网', profession: '软件工程师' };
    updateConversationState(conversationId, defaultResult);
    
    return { success: false, ...defaultResult };
  }
}

/**
 * 获取当前评估维度
 * @param {string} conversationId 会话ID
 * @returns {object|null} 当前维度信息
 */
function getCurrentDimension(conversationId) {
  const conversation = getOrCreateConversation(conversationId);
  
  if (conversation.currentDimensionIndex === undefined || 
      conversation.currentDimensionIndex >= ASSESSMENT_DIMENSIONS.length) {
    return null;
  }
  
  return ASSESSMENT_DIMENSIONS[conversation.currentDimensionIndex];
}

/**
 * 增加维度问题计数
 * @param {string} conversationId 会话ID
 * @param {string} dimension 维度名称
 */
function incrementDimensionQuestionCount(conversationId, dimension) {
  const conversation = getOrCreateConversation(conversationId);
  
  if (!conversation.dimensionQuestionCounts) {
    conversation.dimensionQuestionCounts = {};
  }
  
  conversation.dimensionQuestionCounts[dimension] = 
    (conversation.dimensionQuestionCounts[dimension] || 0) + 1;
  
  updateConversationState(conversationId, { dimensionQuestionCounts: conversation.dimensionQuestionCounts });
}

/**
 * 生成下一个评估问题
 * @param {string} conversationId 会话ID
 * @returns {Promise<string>} 生成的问题
 */
async function generateNextQuestion(conversationId) {
  const conversation = getOrCreateConversation(conversationId);
  
  // 确保必要的状态存在
  if (!conversation.industry || !conversation.profession) {
    return '请问您想了解哪个行业的哪个职业呢？';
  }
  
  // 确定当前维度
  let dimension = getCurrentDimension(conversationId);
  
  // 检查是否需要切换维度
  if (!dimension || 
      (conversation.dimensionQuestionCounts && 
       conversation.dimensionQuestionCounts[dimension.name] >= conversation.questionsPerDimension)) {
    
    // 切换到下一个维度
    const nextIndex = (conversation.currentDimensionIndex || 0) + 1;
    
    // 检查是否所有维度都已完成
    if (nextIndex >= ASSESSMENT_DIMENSIONS.length) {
      // 标记评估完成
      updateConversationState(conversationId, { isCompleted: true });
      return null; // 所有问题都已问完
    }
    
    // 更新当前维度
    updateConversationState(conversationId, { currentDimensionIndex: nextIndex });
    dimension = ASSESSMENT_DIMENSIONS[nextIndex];
  }
  
  // 生成问题
  let question = null;
  
  // 三级问题生成机制：
  // 1. 优先使用模板库中的未使用问题
  // 2. 如果模板库中没有未使用问题，使用大模型生成
  // 3. 如果大模型生成失败，使用默认问题
  
  // 尝试使用模板库中的问题
  const dimensionTemplates = QUESTION_TEMPLATES[dimension.name] || [];
  const unusedTemplates = dimensionTemplates.filter(template => {
    const fullQuestion = template
      .replace('{{industry}}', conversation.industry)
      .replace('{{profession}}', conversation.profession);
    
    const used = usedQuestions.get(conversationId) || new Set();
    return !used.has(fullQuestion);
  });
  
  if (unusedTemplates.length > 0) {
    // 随机选择一个未使用的模板
    const selectedTemplate = unusedTemplates[Math.floor(Math.random() * unusedTemplates.length)];
    question = selectedTemplate
      .replace('{{industry}}', conversation.industry)
      .replace('{{profession}}', conversation.profession);
  } else {
    // 使用大模型生成问题
    try {
      const prompt = buildPrompt('question_generate', '', {
        dimension: dimension.name,
        industry: conversation.industry,
        profession: conversation.profession
      });
      question = await generateResponse(prompt);
    } catch (error) {
      console.error('Failed to generate question with model:', error);
      // 使用默认问题
      question = `请分享一下你在${dimension.name}方面的经历或想法？`;
    }
  }
  
  // 记录已使用的问题
  const used = usedQuestions.get(conversationId) || new Set();
  used.add(question);
  usedQuestions.set(conversationId, used);
  
  // 增加问题计数
  incrementDimensionQuestionCount(conversationId, dimension.name);
  
  // 返回生成的问题
  return question;
}

/**
 * 计算两个字符串的相似度（简化版）
 * @param {string} str1 第一个字符串
 * @param {string} str2 第二个字符串
 * @returns {number} 相似度分数（0-1）
 */
function calculateSimilarity(str1, str2) {
  // 转换为小写并去除空白
  const s1 = str1.toLowerCase().trim();
  const s2 = str2.toLowerCase().trim();
  
  // 如果其中一个字符串为空，相似度为0
  if (!s1 || !s2) {
    return 0;
  }
  
  // 简单的关键词匹配
  const keywords1 = s1.split(/\s+/);
  const keywords2 = s2.split(/\s+/);
  
  let matchCount = 0;
  
  // 统计匹配的关键词数量
  for (const keyword of keywords1) {
    if (keywords2.includes(keyword)) {
      matchCount++;
    }
  }
  
  // 计算相似度分数
  const totalKeywords = Math.max(keywords1.length, keywords2.length);
  return totalKeywords > 0 ? matchCount / totalKeywords : 0;
}

/**
 * 处理用户回答
 * @param {string} conversationId 会话ID
 * @param {string} question 问题
 * @param {string} answer 用户回答
 * @returns {Promise<object>} 处理结果
 */
async function processAnswer(conversationId, question, answer) {
  try {
    // 使用大模型检查相关性
    const prompt = buildPrompt('relevance_check', answer, { question });
    const response = await generateResponse(prompt);
    
    // 解析相关性结果
    let isRelevant = true;
    try {
      const parsed = JSON.parse(response);
      isRelevant = parsed.isRelevant !== false;
    } catch (e) {
      // 如果解析失败，使用备用的相似度计算
      const similarity = calculateSimilarity(question, answer);
      isRelevant = similarity > 0.2; // 阈值可以调整
    }
    
    // 如果回答不相关，生成引导回复
    let feedback = '';
    if (!isRelevant) {
      feedback = `谢谢你的分享！为了更好地了解你在这方面的情况，我们还是回到刚才的问题吧：\n${question}`;
      
      // 保存反馈到会话
      addMessageToConversation(conversationId, 'assistant', feedback);
      
      return {
        isRelevant: false,
        feedback,
        shouldAskNewQuestion: false
      };
    }
    
    // 回答相关，更新评分（简化版评分逻辑）
    const dimension = getCurrentDimension(conversationId);
    if (dimension) {
      updateDimensionScore(conversationId, dimension.name, answer.length);
    }
    
    return {
      isRelevant: true,
      feedback,
      shouldAskNewQuestion: true
    };
  } catch (error) {
    console.error('Error processing answer:', error);
    
    // 返回默认成功，避免阻塞流程
    return {
      isRelevant: true,
      feedback: '',
      shouldAskNewQuestion: true
    };
  }
}

/**
 * 更新维度评分
 * @param {string} conversationId 会话ID
 * @param {string} dimensionName 维度名称
 * @param {number} answerLength 回答长度
 */
function updateDimensionScore(conversationId, dimensionName, answerLength) {
  const conversation = getOrCreateConversation(conversationId);
  
  if (!conversation.dimensionScores) {
    conversation.dimensionScores = {};
  }
  
  // 简化的评分逻辑：基于回答长度
  // 可以根据实际需求调整评分算法
  let score = Math.min(10, Math.floor(answerLength / 20) + 1);
  
  // 累计评分
  const currentScore = conversation.dimensionScores[dimensionName] || 0;
  conversation.dimensionScores[dimensionName] = 
    (currentScore + score) / 2; // 简单平均
  
  // 更新会话状态
  updateConversationState(conversationId, { dimensionScores: conversation.dimensionScores });
}

/**
 * 完成当前问题
 * @param {string} conversationId 会话ID
 */
function completeCurrentQuestion(conversationId) {
  const conversation = getOrCreateConversation(conversationId);
  
  // 更新问题计数
  const newCount = (conversation.questionsAsked || 0) + 1;
  updateConversationState(conversationId, { questionsAsked: newCount });
}

/**
 * 获取下一个维度
 * @param {string} conversationId 会话ID
 * @returns {object|null} 下一个维度信息
 */
function getNextDimension(conversationId) {
  const conversation = getOrCreateConversation(conversationId);
  const nextIndex = (conversation.currentDimensionIndex || 0) + 1;
  
  if (nextIndex >= ASSESSMENT_DIMENSIONS.length) {
    return null;
  }
  
  return ASSESSMENT_DIMENSIONS[nextIndex];
}

/**
 * 生成评估报告
 * @param {string} conversationId 会话ID
 * @returns {Promise<string>} 评估报告
 */
async function generateReport(conversationId) {
  const conversation = getOrCreateConversation(conversationId);
  
  try {
    // 生成对话历史字符串
    const conversationHistory = (conversation.messages || [])
      .filter(msg => msg.role !== 'system')
      .map(msg => `${msg.role === 'user' ? '用户' : '评估官'}: ${msg.content}`)
      .join('\n');
    
    // 使用大模型生成报告
    const prompt = buildPrompt('report_generate', conversationHistory, {
      industry: conversation.industry,
      profession: conversation.profession,
      dimensions: ASSESSMENT_DIMENSIONS.map(d => d.name).join(', ')
    });
    
    let report = await generateResponse(prompt);
    
    // 更新会话状态
    updateConversationState(conversationId, { report });
    
    return report;
  } catch (error) {
    console.error('Failed to generate report:', error);
    
    // 使用备用方法生成简单报告
    return generateSimpleReport(conversation);
  }
}

/**
 * 生成简单评估报告（备用方法）
 * @param {object} conversation 会话对象
 * @returns {string} 简单评估报告
 */
function generateSimpleReport(conversation) {
  const { industry, profession, dimensionScores } = conversation;
  
  // 计算总分
  let totalScore = 0;
  let scoreCount = 0;
  
  Object.values(dimensionScores || {}).forEach(score => {
    totalScore += score;
    scoreCount++;
  });
  
  const avgScore = scoreCount > 0 ? totalScore / scoreCount : 0;
  
  // 评定等级
  let level;
  if (avgScore >= 8) level = '优秀';
  else if (avgScore >= 6) level = '良好';
  else if (avgScore >= 4) level = '一般';
  else level = '需提升';
  
  // 生成报告
  let report = `# 就业成熟度评估报告\n\n`;
  report += `## 评估概述\n`;
  report += `- **评估行业**: ${industry}\n`;
  report += `- **评估职业**: ${profession}\n`;
  report += `- **评估时间**: ${new Date().toLocaleDateString('zh-CN')}\n\n`;
  
  report += `## 维度分析\n`;
  
  ASSESSMENT_DIMENSIONS.forEach(dimension => {
    const score = dimensionScores?.[dimension.name] || 0;
    report += `### ${dimension.name}\n`;
    report += `- **描述**: ${dimension.description}\n`;
    report += `- **评分**: ${score.toFixed(1)}/10\n`;
    report += `- **建议**: ${getDimensionSuggestion(dimension.name, score)}\n\n`;
  });
  
  report += `## 综合评估\n`;
  report += `- **总体评分**: ${avgScore.toFixed(1)}/10\n`;
  report += `- **成熟度等级**: ${level}\n\n`;
  
  report += `## 总结与建议\n`;
  report += getOverallSuggestion(level, avgScore);
  
  return report;
}

/**
 * 获取维度建议
 * @param {string} dimension 维度名称
 * @param {number} score 评分
 * @returns {string} 建议内容
 */
function getDimensionSuggestion(dimension, score) {
  if (score >= 8) {
    return '你在这方面表现优秀，继续保持并寻找进一步提升的空间。';
  } else if (score >= 6) {
    return '你在这方面有良好基础，可以通过更多实践和学习来进一步提升。';
  } else if (score >= 4) {
    return '你在这方面有一定基础，但仍需加强相关知识和技能的学习。';
  } else {
    return '建议你投入更多时间和精力，系统学习和提升这方面的能力。';
  }
}

/**
 * 获取总体建议
 * @param {string} level 等级
 * @param {number} score 分数
 * @returns {string} 总体建议
 */
function getOverallSuggestion(level, score) {
  let suggestion = '';
  
  switch (level) {
    case '优秀':
      suggestion = '恭喜你！你的就业成熟度表现优秀，具备了较强的就业竞争力。建议你进一步明确职业目标，持续学习前沿知识，提升核心竞争力，为未来的职业发展做好充分准备。';
      break;
    case '良好':
      suggestion = '你的就业成熟度表现良好，已经具备了一定的就业竞争力。建议你针对自身的不足进行有针对性的提升，特别是在薄弱环节加强学习和实践，同时积极参与实习和项目，积累更多实战经验。';
      break;
    case '一般':
      suggestion = '你的就业成熟度处于一般水平，需要有计划地提升各方面能力。建议你全面了解目标行业和职业的要求，系统学习相关知识和技能，积极参与社会实践和专业竞赛，逐步提升自己的就业竞争力。';
      break;
    case '需提升':
      suggestion = '你的就业成熟度相对较低，需要付出更多努力来提升。建议你从基础开始，系统学习专业知识，培养通用能力，了解行业动态，积极参与实践活动，制定详细的学习和提升计划，逐步提高自己的就业竞争力。';
      break;
    default:
      suggestion = '建议你基于本次评估结果，制定详细的个人提升计划，有针对性地加强各方面能力的培养，为未来的就业做好充分准备。';
  }
  
  return suggestion + '\n\n记住，就业成熟度的提升是一个持续的过程，需要不断学习、实践和反思。祝你在职业发展道路上取得成功！';
}

/**
 * 获取评估进度
 * @param {string} conversationId 会话ID
 * @returns {object} 进度信息
 */
function getAssessmentProgress(conversationId) {
  const conversation = getOrCreateConversation(conversationId);
  const totalDimensions = ASSESSMENT_DIMENSIONS.length;
  const questionsPerDimension = conversation.questionsPerDimension || 3;
  const totalQuestions = totalDimensions * questionsPerDimension;
  const askedQuestions = conversation.questionsAsked || 0;
  
  // 计算完成百分比
  const progressPercentage = totalQuestions > 0 ? 
    Math.min(100, Math.round((askedQuestions / totalQuestions) * 100)) : 0;
  
  // 计算当前维度进度
  const currentDimension = getCurrentDimension(conversationId);
  const currentDimensionProgress = currentDimension && conversation.dimensionQuestionCounts ? 
    Math.min(100, Math.round((conversation.dimensionQuestionCounts[currentDimension.name] / questionsPerDimension) * 100)) : 0;
  
  return {
    totalQuestions,
    askedQuestions,
    progressPercentage,
    currentDimension: currentDimension?.name || null,
    currentDimensionProgress
  };
}

/**
 * 获取第一个评估问题
 * @param {string} conversationId 会话ID
 * @returns {string} 第一个问题
 */
function getFirstQuestion(conversationId) {
  const conversation = getOrCreateConversation(conversationId);
  
  // 返回初始化时设置的第一个问题
  return conversation.initialMessage || '您好！请问您想了解哪个行业的哪个职业呢？例如：互联网行业-数据分析师、制造业-机械工程师、金融业-客户经理等。';
}

/**
 * 重置评估
 * @param {string} conversationId 会话ID
 */
function resetAssessment(conversationId) {
  // 清除已使用问题记录
  usedQuestions.delete(conversationId);
  
  // 重新初始化评估
  return initializeAssessment(conversationId);
}

// getOrCreateConversation已从modelService直接导入

export {
  // 评估配置
  ASSESSMENT_DIMENSIONS,
  QUESTION_TEMPLATES,
  
  // 评估管理
  initializeAssessment,
  parseIndustryProfession,
  getCurrentDimension,
  incrementDimensionQuestionCount,
  
  // 问题生成
  getFirstQuestion,
  generateNextQuestion,
  
  // 回答处理
  calculateSimilarity,
  processAnswer,
  updateDimensionScore,
  completeCurrentQuestion,
  getNextDimension,
  
  // 报告生成
  generateReport,
  generateSimpleReport,
  
  // 进度管理
  getAssessmentProgress,
  
  // 重置
  resetAssessment
};